/**
 * Created by yezh1 on 2017-11-17.
 */
// import toast from '../toast'
import {
  isEqual,
  uniqWith,
  maxBy,
  minBy,
  meanBy,
  sumBy,
  differenceBy
} from 'lodash'

let array = {}

/**
 * 将数组块划分为指定大小的较小数组
 * @param arr{Array} 入参数组
 * @param size{number} 组块大小
 */
array.chunk = (arr, size) => {
  if (!arr.length || !size) {
    return []
  } else {
    return Array.from(
      {
        length: Math.ceil(arr.length / size)
      },
      (v, i) => {
        return arr.slice(i * size, i * size + size)
      }
    )
  }
}

/**
 * 过滤数组的假值
 * @param arr {Array} 入参数组
 * @param itera {string} 需要判断真假的item属性
 */
array.compact = (arr, itera) => {
  if (arr.length) {
    if (typeof itera === 'string') {
      return arr.filter(n => n[itera])
    } else {
      return arr.filter(Boolean)
    }
  } else {
    return []
  }
}

/**
 * 数组的去重复
 * @param arr{Array}
 * @param itera {function|string} 比较函数（属性） 可填
 * @returns {*}
 */
array.unique = (arr, compator = isEqual) => {
  if (!compator) {
    compator = isEqual
  }
  if (typeof compator === 'string') {
    return uniqWith(arr, (a1, a2) => {
      return a1[compator] === a2[compator]
    })
  } else {
    return uniqWith(arr, compator)
  }
}

/**
 * 获取数组的下标
 * @param arr 目标数组
 * @param val
 * @returns {number}
 */
array.getIndex = (arr, val) => {
  return arr.findIndex(item => item === val)
}

/**
 * 获取数组中最大的元素
 * @param targetArr Array 目标数组 必填
 * @param itera  (function|string) 迭代函数 可填 (对象数组是必填)
 * @returns (*)
 */
array.getMaxItem = (
  arr,
  itera = item => {
    return item
  }
) => {
  if (arr && arr.length) {
    return maxBy(arr, itera)
  } else {
    return false
  }
}

/**
 * 获取数组中最小的元素
 * @param targetArr Array 目标数组 必填
 * @param itera  (function|string) 迭代函数 可填 (对象数组是必填)
 * @returns (*)
 */
array.getMinItem = (
  arr,
  itera = item => {
    return item
  }
) => {
  if (arr && arr.length) {
    if (itera) {
      return minBy(arr, itera)
    } else {
      return minBy(arr)
    }
  } else {
    return false
  }
}

/**
 * 获取数组中平均值
 * @param targetArr Array 目标数组 必填
 * @param itera  (function|string) 迭代函数 可填 (对象数组是必填)
 * @returns (*)
 */
array.getMeanVal = (
  arr,
  itera = item => {
    return item
  }
) => {
  if (arr && arr.length) {
    return meanBy(arr, itera)
  } else {
    return 0
  }
}

/**
 * 获取数组中总值
 * @param targetArr Array 目标数组 必填
 * @param itera  (function|string) 迭代函数 可填 (对象数组是必填)
 * @returns (*)
 */
array.getSumVal = (
  arr,
  itera = item => {
    return item
  }
) => {
  if (arr && arr.length) {
    return sumBy(arr, itera)
  } else {
    return 0
  }
}

/**
 * 获取targetArr中filterArr的补集()
 * @param targetArr Array 目标数组
 * @param filterArr Array 过滤数组
 * @param itera  (function) 迭代函数
 * @returns {array}
 */
array.complementArray = (targetArr, filterArr, itera) => {
  if (!targetArr.length) {
    return []
  }
  if (filterArr && filterArr.length) {
    return differenceBy(targetArr, filterArr, itera)
  } else {
    return targetArr
  }
}

array.compare = (field, sort) => {
  return function(objectN, objectM) {
    let valueN = objectN[field]
    let valueM = objectM[field]
    if (sort === 1) {
      if (Number.isNaN(valueN) || Number.isNaN(valueM)) {
        if (valueN < valueM) return 1
        else if (valueN > valueM) return -1
        else return 0
      } else {
        if (Number.parseFloat(valueN) < Number.parseFloat(valueM)) return 1
        else if (Number.parseFloat(valueN) > Number.parseFloat(valueM)) {
          return -1
        } else return 0
      }
    } else if (sort === 2) {
      if (Number.isNaN(valueN) || Number.isNaN(valueM)) {
        if (valueN < valueM) return -1
        else if (valueN > valueM) return 1
        else return 0
      } else {
        if (Number.parseFloat(valueN) < Number.parseFloat(valueM)) return -1
        else if (Number.parseFloat(valueN) > Number.parseFloat(valueM)) return 1
        else return 0
      }
    } else {
      valueN = objectN.sortId
      valueM = objectM.sortId
      if (valueN < valueM) return -1
      else if (valueN > valueM) return 1
      else return 0
    }
  }
}

export default array
